var _n28;
var cc__extends = __extends;
var cc__decorate = __decorate;
var cc__awaiter = __awaiter;
var cc__generator = __generator;
var cc__spreadArrays = __spreadArrays;
Object.defineProperty(exports, "__esModule", {
  value: true
});
var $zqcc_OverallSystem = require("zqcc_OverallSystem");
var cc__decorator = cc._decorator;
var ccp_ccclass = cc__decorator.ccclass;
var ccp_property = cc__decorator.property;
var def_zqcc_PaintBoard = function (t) {
  function _ctor() {
    // 初始化变量，确保t存在则调用它，否则返回当前上下文
    var instance = null !== t && t.apply(this, arguments) || this;

    // 设置对象的基本属性
    instance.zqcc_gridContainer = null;           // 网格容器初始化为null
    instance.zqcc_previewButton = null;           // 预览按钮初始化为null
    instance.zqcc_filledSprite = [];               // 已填充的精灵数组
    instance.zqcc_nextStepButton = null;          // 下一步按钮初始化为null
    instance.zqcc_lastStepButton = null;          // 上一步按钮初始化为null
    instance.zqcc_importButton = null;            // 导入按钮初始化为null
    instance.zqcc_maskNode = null;                // 遮罩节点初始化为null
    instance.zqcc_parentNode = null;              // 父节点初始化为null
    instance.zqcc_prevStepButton = null;          // 上一步按钮初始化为null
    instance.zqcc_history = [];                    // 历史记录数组
    instance.zqcc_drawHistory = [];                // 绘画历史数组
    instance.zqcc_currentStep = 0;                // 当前步骤初始化为0
    instance.zqcc_cellSize = 14;                  // 单元格大小
    instance.zqcc_rows = 35;                       // 行数
    instance.zqcc_cols = 35;                       // 列数
    instance.zqcc_isAutoPlaying = false;           // 自动播放状态初始化为false
    instance.zqcc_playInterval = 0.01;            // 播放间隔
    instance.ZQCC_COLORS_COUNT = 20;               // 可用颜色数量
    instance.zqcc_cellNodes = new Map();          // 单元格节点存储

    // 返回创建的对象
    return instance;

  }
  cc__extends(_ctor, t);
  _ctor.prototype.start = function () {
    return cc__awaiter(this, undefined, undefined, function () {
      return cc__generator(this, function () {
        this.zqcc_adjustNodeHeight();
        this.zqcc_setupPreviewButton();
        this.zqcc_setupNextStepButton();
        this.zqcc_setupPrevStepButton();
        this.zqcc_setupLastStepButton();
        this.zqcc_setupImportButton();
        return [2];
      });
    });
  };
  _ctor.prototype.zqcc_adjustNodeHeight = function () {
    // 检查网格容器是否存在
    if (this.zqcc_gridContainer) {
      // 计算网格的宽度和高度
      var gridWidth = this.zqcc_cols * this.zqcc_cellSize;     // 网格的总宽度
      var gridHeight = this.zqcc_rows * this.zqcc_cellSize;    // 网格的总高度
      var offsetX = -gridWidth / 2;                  // X轴偏移量
      var offsetY = -gridHeight / 2;                 // Y轴偏移量

      // 设置网格容器的位置
      this.zqcc_gridContainer.setPosition(offsetX, offsetY);

      // 检查父节点是否存在
      if (this.zqcc_parentNode) {
        // 更新父节点的对齐方式
        this.zqcc_parentNode.getComponent(cc.Widget).updateAlignment();

        // 计算父节点的可用高度
        var availableHeight = cc.winSize.height / 2 - this.zqcc_parentNode.y - 50;
        var safeArea = cc.sys.getSafeAreaRect();
        // 确保可用高度不超过网格的高度
        (availableHeight -= cc.winSize.height - safeArea.height - safeArea.y) > gridHeight && (availableHeight = gridHeight);

        // 日志输出可用高度
        cc.log("nodeHeight", availableHeight);
        // 设置父节点的高度
        this.zqcc_parentNode.height = availableHeight;

        // 输出安全区域信息
        console.log("cc.sys.getSafeAreaRect()", safeArea);
      }
    }

  };
  _ctor.prototype.zqcc_redrawToStep = function (t) {
    var instance = this; // 将上下文保存到变量

    // 清除现有的所有单元格
    this.zqcc_clearAllCells();

    // 对历史记录进行排序并重新绘制
    cc__spreadArrays(this.zqcc_history) // 展开历史记录数组
      .sort(function (a, b) {
        return a.step - b.step; // 根据步骤排序
      })
      .forEach(function (stepData) {
        if (stepData.step <= t) { // 检查步骤是否在目标步骤之内
          stepData.positions.forEach(function (position) {
            // 绘制单元格并获取其引用
            var cell = instance.zqcc_drawCell(position.x, position.y, stepData.colorIndex);
            if (cell) { // 确保单元格存在
              if (instance.zqcc_isAutoPlaying && stepData.step === t) {
                cell.scale = 0; // 初始缩放设为0
                // 创建缩放动画效果
                cc.tween(cell).to(0.2, { scale: 1.2 }) // 放大到1.2倍
                  .to(0.1, { scale: 1 })   // 缩小到1倍
                  .start();
              }
              cell.opacity = 255; // 设置单元格的不透明度
            }
          });
        }
      });
  };
  _ctor.prototype.zqcc_drawCell = function (t, e, o) {
    // 检查坐标是否在有效范围内
    if (t < 0 || t >= this.zqcc_cols || e < 0 || e >= this.zqcc_rows) {
      return null; // 返回null表示无效坐标
    }

    var cellKey = t + "," + e; // 创建单元格的唯一键
    var cellNode = this.zqcc_cellNodes.get(cellKey); // 尝试从缓存中获取单元格

    if (!cellNode) { // 如果单元格不存在，则创建新的单元格
      cellNode = new cc.Node("Cell"); // 创建新的节点
      var spriteComponent = cellNode.addComponent(cc.Sprite); // 添加精灵组件
      spriteComponent.spriteFrame = this.zqcc_filledSprite[o]; // 设置精灵帧
      spriteComponent.sizeMode = cc.Sprite.SizeMode.CUSTOM; // 设置尺寸模式

      // 设置单元格属性
      cellNode.parent = this.zqcc_gridContainer; // 设置父节点
      cellNode.width = this.zqcc_cellSize; // 设置宽度
      cellNode.height = this.zqcc_cellSize; // 设置高度
      cellNode.anchorX = 0.5; // 设置X锚点
      cellNode.anchorY = 0.5; // 设置Y锚点
      cellNode.setPosition(this.zqcc_getCellPosition(t, e)); // 根据位置设置位置

      // 将新创建的单元格存储到缓存中
      this.zqcc_cellNodes.set(cellKey, cellNode);
    }

    return cellNode; // 返回单元格节点

  };
  _ctor.prototype.zqcc_getCellPosition = function (t, e) {
    let posX = t * this.zqcc_cellSize + this.zqcc_cellSize / 2;
    let posY = e * this.zqcc_cellSize + this.zqcc_cellSize / 2
    return cc.v3(posX, posY, 0);
  };
  _ctor.prototype.zqcc_setupPreviewButton = function () {
    const instance = this;
    this.zqcc_previewButton && this.zqcc_previewButton.node.on("click", function () {
      instance.zqcc_autoPlayClick();
    });
  };
  _ctor.prototype.zqcc_autoPlayClick = function () {
    if (this.zqcc_isAutoPlaying) {
      this.zqcc_stopPlay();
    } else {
      this.zqcc_startPlay();
    }
  };
  _ctor.prototype.zqcc_startPlay = function () {
    this.zqcc_isAutoPlaying = true; // 设置自动播放状态为true

    // 检查当前步骤是否超过历史记录长度
    if (this.zqcc_currentStep >= this.zqcc_history.length) {
      this.zqcc_clearAllCells(); // 清除所有单元格
      this.zqcc_currentStep = 0; // 重置当前步骤为0
    }

    // 更新预览按钮的颜色
    if (this.zqcc_previewButton) {
      this.zqcc_previewButton.node.color = cc.Color.GREEN; // 将预览按钮的颜色设置为绿色
    }

    // 播放下一步骤
    this.zqcc_playNextStep();

  };
  _ctor.prototype.zqcc_drawStepPosition = function (t, e) {
    // 绘制指定位置的单元格
    var cellNode = this.zqcc_drawCell(t.x, t.y, e);

    // 如果成功绘制了单元格
    if (cellNode) {
      cellNode.scale = 0; // 初始缩放为0

      // 创建缩放动画
      cc.tween(cellNode)
        .to(0.2, { scale: 1.2 }) // 放大至1.2倍
        .to(0.1, { scale: 1 })   // 缩小至1倍
        .start();                // 开始动画

      cellNode.opacity = 255; // 设置单元格的不透明度
    }

    // 检查单元格是否在视口中，若不在，则滚动到该单元格
    if (!this.zqcc_isInViewport(t.x, t.y)) {
      this.zqcc_scrollToCell(t.x, t.y);
    }

  };
  _ctor.prototype.zqcc_playNextStep = function () {
    var instance = this; // 保存当前上下文

    // 检查是否处于自动播放状态
    if (this.zqcc_isAutoPlaying) {
      // 获取当前步骤的历史记录条目
      var currentStepData = cc__spreadArrays(this.zqcc_history)
        .sort(function (a, b) {
          return a.step - b.step; // 根据步骤排序
        })[this.zqcc_currentStep];

      if (currentStepData) {
        // 定义绘制位置的回调函数
        var zqcc_drawPosition = function (index) {
          instance.scheduleOnce(function () {
            instance.zqcc_drawStepPosition(
              cc.v2(currentStepData.positions[index].x, currentStepData.positions[index].y),
              currentStepData.colorIndex
            );
          }, 0.05 * index); // 延时绘制
        };

        // 遍历当前步骤的所有位置
        for (var i = 0; i < currentStepData.positions.length; i++) {
          zqcc_drawPosition(i); // 调用绘制位置函数
        }

        // 计算延迟并安排下一步播放
        var delay = 0.05 * currentStepData.positions.length;
        this.scheduleOnce(function () {
          instance.zqcc_currentStep++; // 增加当前步骤
          instance.zqcc_playNextStep(); // 播放下一步
        }, delay + this.zqcc_playInterval);
      } else {
        this.zqcc_stopPlay(); // 如果没有找到当前步骤，则停止播放
      }
    }
  };
  _ctor.prototype.zqcc_drawWithColor = function (t, e) {
    var instance = this; // 保存当前上下文

    // 对绘制历史进行排序
    var sortedHistory = cc__spreadArrays(this.zqcc_drawHistory).sort(function (a, b) {
      return a.step - b.step; // 按步骤排序
    });

    // 查找指定颜色索引的步骤
    var stepIndex = sortedHistory.findIndex(function (entry) {
      return entry.colorIndex === t;
    });

    if (stepIndex === -1) {
      cc.warn("未找到颜色索引 " + colorIndex + " 对应的步骤"); // 颜色索引未找到时警告
      return {
        duration: 0,
        isFinished: false // 结束标记
      };
    }

    var stepData = sortedHistory[stepIndex]; // 获取步骤数据
    // 遍历步骤的位置
    stepData.positions.forEach(function (position, index) {
      instance.scheduleOnce(function () {
        instance.zqcc_drawStepPosition(cc.v2(position.x, position.y), t); // 绘制位置
        if (e) {
          e(position, index === stepData.positions.length - 1); // 执行回调，传递最后一项标记
        }
      }, 0.02 * index); // 设置延迟
    });

    // 从绘制历史中移除已执行的步骤
    this.zqcc_drawHistory.splice(this.zqcc_drawHistory.indexOf(stepData), 1);
    cc.log("targetStep", stepData.positions.length); // 日志输出目标步骤的长度

    return {
      duration: 0.02 * stepData.positions.length, // 返回绘制的总持续时间
      isFinished: this.zqcc_drawHistory.length === 0 // 检查绘制历史是否已空
    };

  };
  _ctor.prototype.zqcc_stopPlay = function () {
    this.zqcc_isAutoPlaying = false;
    if (this.zqcc_previewButton) {
      this.zqcc_previewButton.node.color = cc.Color.WHITE;
    }
  };
  _ctor.prototype.zqcc_setupNextStepButton = function () {
    const instance = this;
    if (this.zqcc_nextStepButton) {
      this.zqcc_nextStepButton.node.on("click", function () {
        instance.zqcc_playNextStepManually();
      });
    }
  };
  _ctor.prototype.zqcc_playNextStepManually = function () {
    cc.log("zqcc_playNextStepManually", this.zqcc_currentStep); // 日志记录当前步骤
    this.zqcc_stopPlay(); // 停止当前播放

    // 增加当前步骤并检查是否超出历史记录长度
    this.zqcc_currentStep++;
    if (this.zqcc_currentStep > this.zqcc_history.length) {
      this.zqcc_currentStep = 1; // 如果超过长度，重置到第1步
    }

    // 重新绘制到当前步骤
    this.zqcc_redrawToStep(this.zqcc_currentStep);

  };
  _ctor.prototype.zqcc_setupPrevStepButton = function () {
    var t = this;
    if (this.zqcc_prevStepButton) {
      this.zqcc_prevStepButton.node.on("click", function () {
        t.zqcc_playPrevStepManually();
      });
    }
  };
  _ctor.prototype.zqcc_playPrevStepManually = function () {
    this.zqcc_stopPlay(); // 停止当前播放

    // 减少当前步骤并检查是否小于1
    this.zqcc_currentStep--;
    if (this.zqcc_currentStep < 1) {
      this.zqcc_currentStep = this.zqcc_history.length; // 若小于1，则重置为历史记录的最后一步
    }

    // 重新绘制到当前步骤
    this.zqcc_redrawToStep(this.zqcc_currentStep);

  };
  _ctor.prototype.zqcc_setupLastStepButton = function () {
    const instance = this;
    if (this.zqcc_lastStepButton) {
      this.zqcc_lastStepButton.node.on("click", function () {
        instance.zqcc_jumpToLastStep();
      });
    }
  };
  _ctor.prototype.zqcc_jumpToLastStep = function () {
    if (!this.zqcc_isAutoPlaying) {
      this.zqcc_currentStep = this.zqcc_history.length;
      this.zqcc_redrawToStep(this.zqcc_currentStep);
    }
  };
  _ctor.prototype.zqcc_setupImportButton = function () {
    const instance = this;
    if (this.zqcc_importButton) {
      this.zqcc_importButton.node.on("click", function () {
        instance.zqcc_importJson();
      });
    }
  };
  _ctor.prototype.zqcc_clearAllCells = function () {
    this.zqcc_cellNodes.forEach(function (t) {
      t.destroy();
    });
    this.zqcc_cellNodes.clear();
  };
  _ctor.prototype.zqcc_loadGridData = function (t) {
    var instance = this; // 保存当前上下文

    // 验证 JSON 数据格式
    if (this.validateJsonData(t)) {
      this.zqcc_history = []; // 清空历史记录

      // 遍历输入的步骤数据并构建历史记录
      t.s.forEach(function (step) {
        instance.zqcc_history.push({
          positions: step.p.map(function (pos) {
            return {
              x: pos[0], // 提取 x 坐标
              y: pos[1]  // 提取 y 坐标
            };
          }),
          colorIndex: step.c, // 获取颜色索引
          step: step.s        // 获取步骤编号
        });
      });

      // 拷贝历史记录到绘制历史中
      this.zqcc_drawHistory = cc__spreadArrays(this.zqcc_history);
      this.zqcc_currentStep = 0; // 重置当前步骤
      this.zqcc_redrawToStep(this.zqcc_currentStep); // 绘制当前步骤
      this.resetPaintBoardPosition(); // 重置绘画板位置
      cc.log("this.zqcc_history", this.zqcc_history.length); // 输出历史记录长度
    } else {
      cc.warn("无效的JSON格式"); // 输出警告
    }
  };
  _ctor.prototype.resetPaintBoardPosition = function () {
    var zqcc_gridContainer = this.zqcc_gridContainer; // 获取网格容器

    // 检查网格容器及其父节点和遮罩节点是否存在
    if (zqcc_gridContainer && zqcc_gridContainer.parent && this.zqcc_maskNode) {
      var maskHeight = this.zqcc_maskNode.height; // 获取遮罩节点的高度
      var totalHeight = this.zqcc_rows * this.zqcc_cellSize; // 计算总高度
      var newYPosition = maskHeight - totalHeight / 2; // 计算新的Y位置
      var maxYPosition = totalHeight / 2; // 计算最大Y位置

      // 限制新的Y位置不超过最大Y位置
      newYPosition = Math.min(newYPosition, maxYPosition);
      this.zqcc_gridContainer.parent.y = newYPosition; // 设置网格容器的父节点Y位置

      // 输出调试信息
      cc.log("minY", newYPosition);
      cc.log("maxY", maxYPosition);
    }
  };
  _ctor.prototype.validateJsonData = function (t) {
    var instance = this; // 保存当前上下文

    // 检查数据是否存在
    if (t) {
      // 检查是否存在步骤数组
      if (t.s && Array.isArray(t.s)) {
        return t.s.every(function (step, index) {
          // 检查每个步骤的属性
          if (step && Array.isArray(step.p)) {
            // 验证颜色索引
            if (typeof step.c !== "number" || step.c < 0 || step.c >= instance.ZQCC_COLORS_COUNT) {
              cc.warn("步骤 " + index + " 的颜色索引无效:", step.c);
              return false; // 无效颜色索引
            }
            // 验证步骤号
            else if (typeof step.s !== "number") {
              cc.warn("步骤 " + index + " 的步骤号无效:", step.s);
              return false; // 无效步骤号
            }
            // 验证位置数组
            else {
              return step.p.every(function (position, posIndex) {
                if (!Array.isArray(position) || position.length !== 2) {
                  cc.warn("步骤 " + index + " 的位置 " + posIndex + " 格式无效:", position);
                  return false; // 格式无效
                }
                var x = position[0];
                var y = position[1];

                // 验证位置是否在网格内
                return instance.isPointInGrid(x, y) || (cc.warn("步骤 " + index + " 的位置 " + posIndex + " 超出网格范围: x=" + x + ", y=" + y), false);
              });
            }
          } else {
            cc.warn("步骤 " + index + " 的位置数据效:", step);
            return false; // 位置数据无效
          }
        });
      } else {
        cc.warn("数据缺少steps数组或格式错误:", t);
        return false; // 缺少步骤数组
      }
    } else {
      cc.warn("数据为空");
      return false; // 数据为空
    }

  };
  _ctor.prototype.isPointInGrid = function (t, e) {
    return t >= 0 && t < this.zqcc_cols && e >= 0 && e < this.zqcc_rows;
  };
  _ctor.prototype.zqcc_importJson = function () {
    var instance = this; // 保存当前上下文
    var fileInput = document.createElement("input"); // 创建文件输入元素
    fileInput.type = "file"; // 设置输入类型为文件
    fileInput.accept = ".json"; // 只接受.json文件
    fileInput.style.display = "none"; // 隐藏输入框

    // 绑定文件选择后的事件处理
    fileInput.onchange = function (event) {
      var selectedFile;
      var files = event.target.files; // 获取选择的文件
      selectedFile = files ? files[0] : null; // 获取第一个文件

      if (selectedFile) {
        var reader = new FileReader(); // 创建文件读取器
        reader.onload = function (event) {
          try {
            // 解析 JSON 数据
            var jsonData = JSON.parse(event.target.result);
            instance.zqcc_loadGridData(jsonData); // 加载网格数据
          } catch (error) {
            cc.warn("JSON解析错误:", error); // 输出解析错误
          }
        };
        reader.readAsText(selectedFile); // 读取文件内容
      }
    };

    // 触发文件输入对话框
    fileInput.click();

  };
  _ctor.prototype.zqcc_scrollToCell = function (t, e) {
    var zqcc_gridContainer = this.zqcc_gridContainer; // 获取网格容器

    // 检查网格容器及其父节点和遮罩节点是否存在
    if (zqcc_gridContainer && zqcc_gridContainer.parent && this.zqcc_maskNode) {
      var maskHeight = this.zqcc_maskNode.height; // 获取遮罩节点的高度
      var totalHeight = this.zqcc_rows * this.zqcc_cellSize; // 计算总高度
      var parent = zqcc_gridContainer.parent; // 获取网格容器的父节点

      // 计算目标位置
      var offsetY = maskHeight - totalHeight / 2;
      var halfHeight = totalHeight / 2;
      var targetY = offsetY - (e * this.zqcc_cellSize - totalHeight / 2 + offsetY) + maskHeight / 2;

      cc.log("targetY", targetY); // 输出目标Y位置

      // 限制目标Y位置
      var clampedY = Math.max(offsetY, Math.min(halfHeight, targetY));
      cc.log("clampedTargetY", clampedY); // 输出限制后的Y位置

      // 停止所有与目标相关的动画
      cc.Tween.stopAllByTarget(parent);

      // 创建新的动画，平滑移动到目标位置
      cc.tween(parent)
        .to(0.2, { position: cc.v3(0, clampedY, 0) }, { easing: "quartOut" })
        .start(); // 启动动画
    }

  };
  _ctor.prototype.zqcc_isInViewport = function (t, e) {
    var zqcc_gridContainer = this.zqcc_gridContainer; // 获取网格容器

    // 检查网格容器的父节点和遮罩节点是否存在
    if (!zqcc_gridContainer || !zqcc_gridContainer.parent || !this.zqcc_maskNode) {
      return true; // 如果不存在，默认返回true
    }

    var maskHeight = this.zqcc_maskNode.height; // 获取遮罩节点的高度
    var totalHeight = this.zqcc_rows * this.zqcc_cellSize; // 计算总高度
    var parent = zqcc_gridContainer.parent; // 获取网格容器的父节点

    // 计算调整后的Y位置
    var adjustedY = e * this.zqcc_cellSize - totalHeight / 2 + parent.y;

    // 返回是否在可见范围内
    return adjustedY >= 0 && adjustedY <= maskHeight;

  };
  _ctor.prototype.zqcc_getSteps = function () {
    return this.zqcc_history;
  };
  _ctor.prototype.zqcc_onSaveAsPNG = function () {
    this.zqcc_saveAsPNG();
  };
  _ctor.prototype.zqcc_saveAsPNG = function () {
    var renderTexture = new cc.RenderTexture(); // 创建渲染纹理
    renderTexture.initWithSize(490, 490); // 初始化大小为490x490

    var renderNode = new cc.Node(); // 创建新的节点
    renderNode.parent = cc.director.getScene(); // 将其作为场景的子节点
    renderNode.setContentSize(490, 490); // 设置节点大小

    // 将节点的局部坐标转换为世界空间坐标
    var worldPosition = this.node.convertToWorldSpaceAR(cc.v2(0, 0));
    // 将世界空间坐标转换回节点空间
    var localPosition = renderNode.convertToNodeSpaceAR(worldPosition);
    renderNode.setPosition(localPosition); // 设置节点位置

    var cameraNode = new cc.Node(); // 创建新的相机节点
    var cameraComponent = cameraNode.addComponent(cc.Camera); // 添加相机组件
    cameraComponent.clearFlags = cc.Camera.ClearFlags.COLOR; // 设置清除标志为颜色
    cameraComponent.backgroundColor = cc.color(0, 0, 0, 0); // 设置背景色为透明
    cameraComponent.targetTexture = renderTexture; // 设置渲染目标为渲染纹理

    renderNode.addChild(cameraNode); // 将相机节点添加到渲染节点
    cameraNode.setPosition(0, 0, 1000); // 设置相机位置
    cameraComponent.orthoSize = 245; // 正交视图大小
    cameraComponent.zoomRatio = 3; // 缩放比率
    cameraComponent.render(this.node); // 渲染目标节点

    // 创建一个用于存储图像的 canvas
    var imageCanvas = document.createElement("canvas");
    imageCanvas.width = 490;
    imageCanvas.height = 490;
    var imageContext = imageCanvas.getContext("2d"); // 获取上下文

    if (imageContext) {
      var pixelData = renderTexture.readPixels(); // 读取像素数据
      var imageData = imageContext.createImageData(490, 490); // 创建图像数据

      // 像素数据转换
      for (var p = 0; p < 490; p++) {
        for (var d = 0; d < 490; d++) {
          var inputIndex = 4 * (490 * p + d); // 输入像素位置
          var outputIndex = 4 * (490 * (489 - p) + d); // 输出像素位置，进行垂直翻转
          imageData.data[outputIndex] = pixelData[inputIndex]; // R
          imageData.data[outputIndex + 1] = pixelData[inputIndex + 1]; // G
          imageData.data[outputIndex + 2] = pixelData[inputIndex + 2]; // B
          imageData.data[outputIndex + 3] = pixelData[inputIndex + 3]; // A
        }
      }

      imageContext.putImageData(imageData, 0, 0); // 将图像数据放入上下文

      // 创建另一个 canvas 用于缩放图像
      var scaledCanvas = document.createElement("canvas");
      scaledCanvas.width = 196;
      scaledCanvas.height = 196;
      var scaledContext = scaledCanvas.getContext("2d");

      if (scaledContext) {
        scaledContext.drawImage(imageCanvas, 0, 0, 196, 196); // 缩放图像

        // 创建下载链接
        var downloadLink = document.createElement("a");
        downloadLink.download = $zqcc_OverallSystem.sers().userSrv.getFeibiaoData().level + ".png"; // 设置下载文件名
        downloadLink.href = scaledCanvas.toDataURL("image/png"); // 获取图像为 PNG 数据
        downloadLink.click(); // 模拟点击下载
      }
    }

    // 清理
    renderNode.destroy(); // 销毁渲染节点
    renderTexture.destroy(); // 销毁渲染纹理

  };
  cc__decorate([ccp_property(cc.Node)], _ctor.prototype, "zqcc_gridContainer", undefined);
  cc__decorate([ccp_property(cc.Button)], _ctor.prototype, "zqcc_previewButton", undefined);
  cc__decorate([ccp_property(cc.SpriteFrame)], _ctor.prototype, "zqcc_filledSprite", undefined);
  cc__decorate([ccp_property(cc.Button)], _ctor.prototype, "zqcc_nextStepButton", undefined);
  cc__decorate([ccp_property(cc.Button)], _ctor.prototype, "zqcc_lastStepButton", undefined);
  cc__decorate([ccp_property(cc.Button)], _ctor.prototype, "zqcc_importButton", undefined);
  cc__decorate([ccp_property(cc.Node)], _ctor.prototype, "zqcc_maskNode", undefined);
  cc__decorate([ccp_property(cc.Node)], _ctor.prototype, "zqcc_parentNode", undefined);
  cc__decorate([ccp_property(cc.Button)], _ctor.prototype, "zqcc_prevStepButton", undefined);
  return cc__decorate([ccp_ccclass], _ctor);
}(cc.Component);
exports.default = def_zqcc_PaintBoard;